const express = require('express');
const axios = require('axios');
const router = express.Router();

// 公共API基础地址
const PUBLIC_API_BASE = 'http://10.1.6.130/api/demo';

// 创建axios实例用于转发请求到公共API
const publicApiClient = axios.create({
  baseURL: PUBLIC_API_BASE,
  timeout: 30000,
  headers: {
    'Content-Type': 'application/json'
  }
});

// 用户注册路由 - 转发到公共API
router.post('/reg', async (req, res) => {
  try {
    const userData = req.body;

    // 验证必要字段
    const requiredFields = ['username', 'pwd', 'age', 'realName', 'email', 'stuNum', 'className'];
    const missingFields = requiredFields.filter(field => !userData[field]);

    if (missingFields.length > 0) {
      return res.status(400).json({
        errno: 1,
        message: `缺少必要字段: ${missingFields.join(', ')}`
      });
    }

    // 转发注册请求到公共API
    const response = await publicApiClient.post('/reg', userData);

    // 返回公共API的响应
    res.json(response.data);
  } catch (error) {
    console.error('注册请求转发失败:', error.message);

    if (error.response) {
      // 如果公共API返回错误，将错误信息转发给前端
      res.status(error.response.status).json(error.response.data);
    } else if (error.request) {
      // 如果请求发送失败
      res.status(500).json({
        errno: 1,
        message: '无法连接到公共API服务器，请稍后重试'
      });
    } else {
      // 其他错误
      res.status(500).json({
        errno: 1,
        message: '服务器内部错误'
      });
    }
  }
});

// 用户登录路由 - 转发到公共API
router.post('/login', async (req, res) => {
  try {
    const { username, pwd } = req.body;

    if (!username || !pwd) {
      return res.status(400).json({
        errno: 1,
        message: '用户名和密码不能为空'
      });
    }

    // 转发登录请求到公共API
    const response = await publicApiClient.post('/login', { username, pwd });

    // 返回公共API的响应
    res.json(response.data);
  } catch (error) {
    console.error('登录请求转发失败:', error.message);

    if (error.response) {
      // 如果公共API返回错误，将错误信息转发给前端
      res.status(error.response.status).json(error.response.data);
    } else if (error.request) {
      // 如果请求发送失败
      res.status(500).json({
        errno: 1,
        message: '无法连接到公共API服务器，请稍后重试'
      });
    } else {
      // 其他错误
      res.status(500).json({
        errno: 1,
        message: '服务器内部错误'
      });
    }
  }
});

// 获取所有项目路由 - 转发到公共API
router.get('/getallitems', async (req, res) => {
  try {
    const { typeIndex, courseId, userid, articleid } = req.query;

    if (typeIndex === undefined) {
      return res.status(400).json({
        errno: 1,
        message: '缺少typeIndex参数'
      });
    }

    const params = { typeIndex };
    if (courseId) {
      params.courseId = courseId;
    }
    if (userid) {
      params.userid = userid;
    }
    if (articleid) {
      params.articleid = articleid;
    }

    // 转发请求到公共API
    const response = await publicApiClient.get('/getallitems', { params });

    // 返回公共API的响应
    res.json(response.data);
  } catch (error) {
    console.error('获取项目列表请求转发失败:', error.message);

    if (error.response) {
      res.status(error.response.status).json(error.response.data);
    } else if (error.request) {
      res.status(500).json({
        errno: 1,
        message: '无法连接到公共API服务器，请稍后重试'
      });
    } else {
      res.status(500).json({
        errno: 1,
        message: '服务器内部错误'
      });
    }
  }
});

// 获取单个项目路由 - 转发到公共API
router.get('/getsingle', async (req, res) => {
  try {
    const { id, typeIndex } = req.query;

    if (!id || typeIndex === undefined) {
      return res.status(400).json({
        errno: 1,
        message: '缺少必要参数'
      });
    }

    // 转发请求到公共API
    const response = await publicApiClient.get('/getsingle', { params: { id, typeIndex } });

    // 返回公共API的响应
    res.json(response.data);
  } catch (error) {
    console.error('获取单个项目请求转发失败:', error.message);

    if (error.response) {
      res.status(error.response.status).json(error.response.data);
    } else if (error.request) {
      res.status(500).json({
        errno: 1,
        message: '无法连接到公共API服务器，请稍后重试'
      });
    } else {
      res.status(500).json({
        errno: 1,
        message: '服务器内部错误'
      });
    }
  }
});

// 添加项目路由 - 转发到公共API
router.post('/additem', async (req, res) => {
  try {
    const itemData = req.body;

    if (!itemData.typeIndex) {
      return res.status(400).json({
        errno: 1,
        message: '缺少typeIndex参数'
      });
    }

    // 转发请求到公共API
    const response = await publicApiClient.post('/additem', itemData);

    // 返回公共API的响应
    res.json(response.data);
  } catch (error) {
    console.error('添加项目请求转发失败:', error.message);

    if (error.response) {
      res.status(error.response.status).json(error.response.data);
    } else if (error.request) {
      res.status(500).json({
        errno: 1,
        message: '无法连接到公共API服务器，请稍后重试'
      });
    } else {
      res.status(500).json({
        errno: 1,
        message: '服务器内部错误'
      });
    }
  }
});

module.exports = router;